home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / m62.c < prev    next >
C/C++ Source or Header  |  2000-05-04  |  26KB  |  1,117 lines
  1. /***************************************************************************
  2.  
  3.   Video Hardware for Irem Games:
  4.   Battle Road, Lode Runner, Kid Niki, Spelunker
  5.  
  6. ***************************************************************************/
  7.  
  8. #include "driver.h"
  9. #include "vidhrdw/generic.h"
  10.  
  11.  
  12.  
  13. static int flipscreen;
  14. static const unsigned char *sprite_height_prom;
  15. static int kidniki_background_bank;
  16. static int irem_background_hscroll;
  17. static int irem_background_vscroll;
  18. static int kidniki_text_vscroll;
  19. static int spelunk2_palbank;
  20.  
  21. unsigned char *irem_textram;
  22. size_t irem_textram_size;
  23.  
  24.  
  25. static const struct rectangle kungfum_spritevisiblearea =
  26. {
  27.     16*8, (64-16)*8-1,
  28.     10*8, 32*8-1
  29. };
  30. static const struct rectangle kungfum_flipspritevisiblearea =
  31. {
  32.     16*8, (64-16)*8-1,
  33.     0*8, 22*8-1
  34. };
  35.  
  36. /***************************************************************************
  37.  
  38.   Convert the color PROMs into a more useable format.
  39.  
  40.   Kung Fu Master has a six 256x4 palette PROMs (one per gun; three for
  41.   characters, three for sprites).
  42.   I don't know the exact values of the resistors between the RAM and the
  43.   RGB output. I assumed these values (the same as Commando)
  44.  
  45.   bit 3 -- 220 ohm resistor  -- RED/GREEN/BLUE
  46.         -- 470 ohm resistor  -- RED/GREEN/BLUE
  47.         -- 1  kohm resistor  -- RED/GREEN/BLUE
  48.   bit 0 -- 2.2kohm resistor  -- RED/GREEN/BLUE
  49.  
  50. ***************************************************************************/
  51. void irem_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  52. {
  53.     int i;
  54.  
  55.  
  56.     for (i = 0;i < Machine->drv->total_colors;i++)
  57.     {
  58.         int bit0,bit1,bit2,bit3;
  59.  
  60.         /* red component */
  61.         bit0 = (color_prom[0] >> 0) & 0x01;
  62.         bit1 = (color_prom[0] >> 1) & 0x01;
  63.         bit2 = (color_prom[0] >> 2) & 0x01;
  64.         bit3 = (color_prom[0] >> 3) & 0x01;
  65.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  66.         /* green component */
  67.         bit0 = (color_prom[Machine->drv->total_colors] >> 0) & 0x01;
  68.         bit1 = (color_prom[Machine->drv->total_colors] >> 1) & 0x01;
  69.         bit2 = (color_prom[Machine->drv->total_colors] >> 2) & 0x01;
  70.         bit3 = (color_prom[Machine->drv->total_colors] >> 3) & 0x01;
  71.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  72.         /* blue component */
  73.         bit0 = (color_prom[2*Machine->drv->total_colors] >> 0) & 0x01;
  74.         bit1 = (color_prom[2*Machine->drv->total_colors] >> 1) & 0x01;
  75.         bit2 = (color_prom[2*Machine->drv->total_colors] >> 2) & 0x01;
  76.         bit3 = (color_prom[2*Machine->drv->total_colors] >> 3) & 0x01;
  77.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  78.  
  79.         color_prom++;
  80.     }
  81.  
  82.     color_prom += 2*Machine->drv->total_colors;
  83.     /* color_prom now points to the beginning of the sprite height table */
  84.  
  85.     sprite_height_prom = color_prom;    /* we'll need this at run time */
  86. }
  87.  
  88. void battroad_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  89. {
  90.     int i;
  91.  
  92.  
  93.     for (i = 0;i < 512;i++)
  94.     {
  95.         int bit0,bit1,bit2,bit3;
  96.  
  97.         /* red component */
  98.         bit0 = (color_prom[0] >> 0) & 0x01;
  99.         bit1 = (color_prom[0] >> 1) & 0x01;
  100.         bit2 = (color_prom[0] >> 2) & 0x01;
  101.         bit3 = (color_prom[0] >> 3) & 0x01;
  102.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  103.         /* green component */
  104.         bit0 = (color_prom[512] >> 0) & 0x01;
  105.         bit1 = (color_prom[512] >> 1) & 0x01;
  106.         bit2 = (color_prom[512] >> 2) & 0x01;
  107.         bit3 = (color_prom[512] >> 3) & 0x01;
  108.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  109.         /* blue component */
  110.         bit0 = (color_prom[2*512] >> 0) & 0x01;
  111.         bit1 = (color_prom[2*512] >> 1) & 0x01;
  112.         bit2 = (color_prom[2*512] >> 2) & 0x01;
  113.         bit3 = (color_prom[2*512] >> 3) & 0x01;
  114.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  115.  
  116.         color_prom++;
  117.     }
  118.  
  119.     color_prom += 2*512;
  120.     /* color_prom now points to the beginning of the character color prom */
  121.  
  122.     for (i = 0;i < 32;i++)
  123.     {
  124.         int bit0,bit1,bit2;
  125.  
  126.  
  127.         bit0 = (color_prom[i] >> 0) & 0x01;
  128.         bit1 = (color_prom[i] >> 1) & 0x01;
  129.         bit2 = (color_prom[i] >> 2) & 0x01;
  130.         *(palette++) = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
  131.         bit0 = (color_prom[i] >> 3) & 0x01;
  132.         bit1 = (color_prom[i] >> 4) & 0x01;
  133.         bit2 = (color_prom[i] >> 5) & 0x01;
  134.         *(palette++) = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
  135.         bit0 = 0;
  136.         bit1 = (color_prom[i] >> 6) & 0x01;
  137.         bit2 = (color_prom[i] >> 7) & 0x01;
  138.         *(palette++) = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
  139.  
  140.     }
  141.  
  142.     color_prom += 32;
  143.     /* color_prom now points to the beginning of the sprite height table */
  144.  
  145.     sprite_height_prom = color_prom;    /* we'll need this at run time */
  146. }
  147.  
  148. void spelunk2_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  149. {
  150.     int i;
  151.  
  152.  
  153.     /* chars */
  154.     for (i = 0;i < 512;i++)
  155.     {
  156.         int bit0,bit1,bit2,bit3;
  157.  
  158.         /* red component */
  159.         bit0 = (color_prom[0] >> 0) & 0x01;
  160.         bit1 = (color_prom[0] >> 1) & 0x01;
  161.         bit2 = (color_prom[0] >> 2) & 0x01;
  162.         bit3 = (color_prom[0] >> 3) & 0x01;
  163.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  164.         /* green component */
  165.         bit0 = (color_prom[0] >> 4) & 0x01;
  166.         bit1 = (color_prom[0] >> 5) & 0x01;
  167.         bit2 = (color_prom[0] >> 6) & 0x01;
  168.         bit3 = (color_prom[0] >> 7) & 0x01;
  169.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  170.         /* blue component */
  171.         bit0 = (color_prom[2*256] >> 0) & 0x01;
  172.         bit1 = (color_prom[2*256] >> 1) & 0x01;
  173.         bit2 = (color_prom[2*256] >> 2) & 0x01;
  174.         bit3 = (color_prom[2*256] >> 3) & 0x01;
  175.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  176.  
  177.         color_prom++;
  178.     }
  179.  
  180.     color_prom += 2*256;
  181.  
  182.     /* sprites */
  183.     for (i = 0;i < 256;i++)
  184.     {
  185.         int bit0,bit1,bit2,bit3;
  186.  
  187.         /* red component */
  188.         bit0 = (color_prom[0] >> 0) & 0x01;
  189.         bit1 = (color_prom[0] >> 1) & 0x01;
  190.         bit2 = (color_prom[0] >> 2) & 0x01;
  191.         bit3 = (color_prom[0] >> 3) & 0x01;
  192.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  193.         /* green component */
  194.         bit0 = (color_prom[256] >> 0) & 0x01;
  195.         bit1 = (color_prom[256] >> 1) & 0x01;
  196.         bit2 = (color_prom[256] >> 2) & 0x01;
  197.         bit3 = (color_prom[256] >> 3) & 0x01;
  198.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  199.         /* blue component */
  200.         bit0 = (color_prom[2*256] >> 0) & 0x01;
  201.         bit1 = (color_prom[2*256] >> 1) & 0x01;
  202.         bit2 = (color_prom[2*256] >> 2) & 0x01;
  203.         bit3 = (color_prom[2*256] >> 3) & 0x01;
  204.         *(palette++) =  0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  205.  
  206.         color_prom++;
  207.     }
  208.  
  209.     color_prom += 2*256;
  210.  
  211.  
  212.     /* color_prom now points to the beginning of the sprite height table */
  213.     sprite_height_prom = color_prom;    /* we'll need this at run time */
  214. }
  215.  
  216.  
  217.  
  218. int ldrun_vh_start(void)
  219. {
  220.     irem_background_hscroll = 0;
  221.     irem_background_vscroll = 0;
  222.     return generic_vh_start();
  223. }
  224.  
  225.  
  226. static int irem_vh_start( int width, int height )
  227. {
  228.     irem_background_hscroll = 0;
  229.     irem_background_vscroll = 0;
  230.  
  231.     if ((dirtybuffer = malloc(videoram_size)) == 0)
  232.         return 1;
  233.     memset(dirtybuffer,1,videoram_size);
  234.  
  235.     if ((tmpbitmap = osd_create_bitmap(width,height)) == 0)
  236.     {
  237.         free(dirtybuffer);
  238.         return 1;
  239.     }
  240.  
  241.     return 0;
  242. }
  243.  
  244. int kidniki_vh_start(void)
  245. {
  246.     return irem_vh_start(512,256);
  247. }
  248.  
  249. int spelunkr_vh_start(void)
  250. {
  251.     return irem_vh_start(512,512);
  252. }
  253.  
  254.  
  255.  
  256. WRITE_HANDLER( irem_flipscreen_w )
  257. {
  258.     /* screen flip is handled both by software and hardware */
  259.     data ^= ~readinputport(4) & 1;
  260.  
  261.     if (flipscreen != (data & 1))
  262.     {
  263.         flipscreen = data & 1;
  264.         memset(dirtybuffer,1,videoram_size);
  265.     }
  266.  
  267.     coin_counter_w(0,data & 2);
  268.     coin_counter_w(1,data & 4);
  269. }
  270.  
  271.  
  272. WRITE_HANDLER( irem_background_hscroll_w )
  273. {
  274.     switch(offset)
  275.     {
  276.         case 0:
  277.             irem_background_hscroll = (irem_background_hscroll&0xff00)|data;
  278.             break;
  279.  
  280.         case 1:
  281.             irem_background_hscroll = (irem_background_hscroll&0xff)|(data<<8);
  282.             break;
  283.     }
  284. }
  285.  
  286. WRITE_HANDLER( kungfum_scroll_low_w )
  287. {
  288.     irem_background_hscroll_w(0,data);
  289. }
  290. WRITE_HANDLER( kungfum_scroll_high_w )
  291. {
  292.     irem_background_hscroll_w(1,data);
  293. }
  294.  
  295. WRITE_HANDLER( irem_background_vscroll_w ){
  296.     switch( offset ){
  297.         case 0:
  298.         irem_background_vscroll = (irem_background_vscroll&0xff00)|data;
  299.         break;
  300.  
  301.         case 1:
  302.         irem_background_vscroll = (irem_background_vscroll&0xff)|(data<<8);
  303.         break;
  304.     }
  305. }
  306.  
  307. WRITE_HANDLER( battroad_scroll_w ){
  308.     switch( offset ){
  309.         case 0:
  310.         irem_background_vscroll_w(0, data);
  311.         break;
  312.  
  313.         case 1:
  314.         irem_background_hscroll_w(1, data);
  315.         break;
  316.  
  317.         case 2:
  318.         irem_background_hscroll_w(0, data);
  319.         break;
  320.     }
  321. }
  322.  
  323. WRITE_HANDLER( ldrun3_vscroll_w )
  324. {
  325.     irem_background_vscroll = data;
  326. }
  327.  
  328. WRITE_HANDLER( ldrun4_hscroll_w )
  329. {
  330.     irem_background_hscroll_w(offset ^ 1,data);
  331. }
  332.  
  333. WRITE_HANDLER( kidniki_text_vscroll_w )
  334. {
  335.     switch (offset)
  336.     {
  337.         case 0:
  338.         kidniki_text_vscroll = (kidniki_text_vscroll & 0xff00) | data;
  339.         break;
  340.  
  341.         case 1:
  342.         kidniki_text_vscroll = (kidniki_text_vscroll & 0xff) | (data << 8);
  343.         break;
  344.     }
  345. }
  346.  
  347. WRITE_HANDLER( kidniki_background_bank_w )
  348. {
  349.     if (kidniki_background_bank != (data & 1))
  350.     {
  351.         kidniki_background_bank = data & 1;
  352.         memset(dirtybuffer,1,videoram_size);
  353.     }
  354. }
  355.  
  356. WRITE_HANDLER( spelunkr_palbank_w )
  357. {
  358.     if (spelunk2_palbank != (data & 0x01))
  359.     {
  360.         spelunk2_palbank = data & 0x01;
  361.         memset(dirtybuffer,1,videoram_size);
  362.     }
  363. }
  364.  
  365. WRITE_HANDLER( spelunk2_gfxport_w )
  366. {
  367.     switch( offset )
  368.     {
  369.         case 0:
  370.         irem_background_vscroll_w(0,data);
  371.         break;
  372.  
  373.         case 1:
  374.         irem_background_hscroll_w(0,data);
  375.         break;
  376.  
  377.         case 2:
  378.         irem_background_hscroll_w(1,(data&2)>>1);
  379.         irem_background_vscroll_w(1,(data&1));
  380.         if (spelunk2_palbank != ((data & 0x0c) >> 2))
  381.         {
  382.             spelunk2_palbank = (data & 0x0c) >> 2;
  383.             memset(dirtybuffer,1,videoram_size);
  384.         }
  385.         break;
  386.     }
  387. }
  388.  
  389.  
  390.  
  391. /***************************************************************************
  392.  
  393.   Draw the game screen in the given osd_bitmap.
  394.   Do NOT call osd_update_display() from this function, it will be called by
  395.   the main emulation engine.
  396.  
  397. ***************************************************************************/
  398. static void draw_sprites(struct osd_bitmap *bitmap,
  399.                          const struct rectangle *spritevisiblearea,
  400.                          const struct rectangle *flipspritevisiblearea )
  401. {
  402.     int offs;
  403.  
  404.     /* sprites must be drawn in this order to get correct priority */
  405.     for (offs = 0;offs < spriteram_size;offs += 8)
  406.     {
  407.         int i,incr,code,col,flipx,flipy,sx,sy;
  408.  
  409.  
  410.         code = spriteram[offs+4] + ((spriteram[offs+5] & 0x07) << 8);
  411.         col = spriteram[offs+0] & 0x1f;
  412.         sx = 256 * (spriteram[offs+7] & 1) + spriteram[offs+6],
  413.         sy = 256+128-15 - (256 * (spriteram[offs+3] & 1) + spriteram[offs+2]),
  414.         flipx = spriteram[offs+5] & 0x40;
  415.         flipy = spriteram[offs+5] & 0x80;
  416.  
  417.         i = sprite_height_prom[(code >> 5) & 0x1f];
  418.         if (i == 1)    /* double height */
  419.         {
  420.             code &= ~1;
  421.             sy -= 16;
  422.         }
  423.         else if (i == 2)    /* quadruple height */
  424.         {
  425.             i = 3;
  426.             code &= ~3;
  427.             sy -= 3*16;
  428.         }
  429.  
  430.         if (flipscreen)
  431.         {
  432.             sx = 496 - sx;
  433.             sy = 242 - i*16 - sy;    /* sprites are slightly misplaced by the hardware */
  434.             flipx = !flipx;
  435.             flipy = !flipy;
  436.         }
  437.  
  438.         if (flipy)
  439.         {
  440.             incr = -1;
  441.             code += i;
  442.         }
  443.         else incr = 1;
  444.  
  445.         do
  446.         {
  447.             drawgfx(bitmap,Machine->gfx[1],
  448.                     code + i * incr,col,
  449.                     flipx,flipy,
  450.                     sx,sy + 16 * i,
  451.                     flipscreen ? flipspritevisiblearea : spritevisiblearea,TRANSPARENCY_PEN,0);
  452.  
  453.             i--;
  454.         } while (i >= 0);
  455.     }
  456. }
  457.  
  458.  
  459. static void draw_priority_sprites(struct osd_bitmap *bitmap, int prioritylayer)
  460. {
  461.     int offs;
  462.  
  463.     /* sprites must be drawn in this order to get correct priority */
  464.     for (offs = 0;offs < spriteram_size;offs += 8)
  465.     {
  466.         int i,incr,code,col,flipx,flipy,sx,sy;
  467.  
  468.  
  469.         if (!prioritylayer || (prioritylayer && (spriteram[offs] & 0x10)))
  470.         {
  471.             code = spriteram[offs+4] + ((spriteram[offs+5] & 0x07) << 8);
  472.             col = spriteram[offs+0] & 0x0f;
  473.             sx = 256 * (spriteram[offs+7] & 1) + spriteram[offs+6],
  474.             sy = 256+128-15 - (256 * (spriteram[offs+3] & 1) + spriteram[offs+2]),
  475.             flipx = spriteram[offs+5] & 0x40;
  476.             flipy = spriteram[offs+5] & 0x80;
  477.  
  478.             i = sprite_height_prom[(code >> 5) & 0x1f];
  479.             if (i == 1)    /* double height */
  480.             {
  481.                 code &= ~1;
  482.                 sy -= 16;
  483.             }
  484.             else if (i == 2)    /* quadruple height */
  485.             {
  486.                 i = 3;
  487.                 code &= ~3;
  488.                 sy -= 3*16;
  489.             }
  490.  
  491.             if (flipscreen)
  492.             {
  493.                 sx = 496 - sx;
  494.                 sy = 242 - i*16 - sy;    /* sprites are slightly misplaced by the hardware */
  495.                 flipx = !flipx;
  496.                 flipy = !flipy;
  497.             }
  498.  
  499.             if (flipy)
  500.             {
  501.                 incr = -1;
  502.                 code += i;
  503.             }
  504.             else incr = 1;
  505.  
  506.             do
  507.             {
  508.                 drawgfx(bitmap,Machine->gfx[1],
  509.                         code + i * incr,col,
  510.                         flipx,flipy,
  511.                         sx,sy + 16 * i,
  512.                         &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  513.  
  514.                 i--;
  515.             } while (i >= 0);
  516.         }
  517.     }
  518. }
  519.  
  520.  
  521. void kungfum_draw_background(struct osd_bitmap *bitmap)
  522. {
  523.     int offs,i;
  524.  
  525.  
  526.     /* for every character in the Video RAM, check if it has been modified */
  527.     /* since last time and update it accordingly. */
  528.     for (offs = videoram_size/2 - 1;offs >= 0;offs--)
  529.     {
  530.         if (dirtybuffer[offs] || dirtybuffer[offs+0x800])
  531.         {
  532.             int sx,sy,flipx,flipy;
  533.  
  534.  
  535.             dirtybuffer[offs] = dirtybuffer[offs+0x800] = 0;
  536.  
  537.             sx = offs % 64;
  538.             sy = offs / 64;
  539.             flipx = videoram[offs+0x800] & 0x20;
  540.             flipy = 0;
  541.             if (flipscreen)
  542.             {
  543.                 sx = 63 - sx;
  544.                 sy = 31 - sy;
  545.                 flipx = !flipx;
  546.                 flipy = !flipy;
  547.             }
  548.  
  549.             drawgfx(tmpbitmap,Machine->gfx[0],
  550.                     videoram[offs] + 4 * (videoram[offs+0x800] & 0xc0),
  551.                     videoram[offs+0x800] & 0x1f,
  552.                     flipx,flipy,
  553.                     8*sx,8*sy,
  554.                     0,TRANSPARENCY_NONE,0);
  555.         }
  556.     }
  557.  
  558.  
  559.     /* copy the temporary bitmap to the screen */
  560.     {
  561.         int scrollx[32];
  562.  
  563.  
  564.         if (flipscreen)
  565.         {
  566.             for (i = 31;i > 25;i--)
  567.                 scrollx[i] = 0;
  568.             for (i = 25;i >= 0;i--)
  569.                 scrollx[i] = irem_background_hscroll;
  570.         }
  571.         else
  572.         {
  573.             for (i = 0;i < 6;i++)
  574.                 scrollx[i] = 0;
  575.             for (i = 6;i < 32;i++)
  576.                 scrollx[i] = -irem_background_hscroll;
  577.         }
  578.  
  579.         copyscrollbitmap(bitmap,tmpbitmap,32,scrollx,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  580.     }
  581. }
  582.  
  583. static void battroad_draw_background(struct osd_bitmap *bitmap, int prioritylayer)
  584. {
  585.     int offs;
  586.  
  587.  
  588.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  589.     {
  590.         if ((dirtybuffer[offs] || dirtybuffer[offs+1]) && !(!prioritylayer && (videoram[offs+1] & 0x04)))
  591.         {
  592.             int sx,sy;
  593.  
  594.  
  595.             dirtybuffer[offs] = 0;
  596.             dirtybuffer[offs+1] = 0;
  597.  
  598.             sx = (offs/2) % 64;
  599.             sy = (offs/2) / 64;
  600.  
  601.             if (flipscreen)
  602.             {
  603.                 sx = 63 - sx;
  604.                 sy = 31 - sy;
  605.             }
  606.  
  607.             drawgfx(tmpbitmap,Machine->gfx[0],
  608.                     videoram[offs] + ((videoram[offs+1] & 0x40) << 3) + ((videoram[offs + 1] & 0x10) << 4),
  609.                     videoram[offs+1] & 0x0f,
  610.                     flipscreen,flipscreen,
  611.                     8*sx,8*sy,
  612.                     0,TRANSPARENCY_NONE,0);
  613.         }
  614.     }
  615.  
  616.  
  617.     {
  618.         int scrollx, scrolly;
  619.  
  620.         if (flipscreen)
  621.         {
  622.             scrollx = irem_background_hscroll;
  623.             scrolly = irem_background_vscroll;
  624.         }
  625.         else
  626.         {
  627.             scrollx = -irem_background_hscroll;
  628.             scrolly = -irem_background_vscroll;
  629.         }
  630.  
  631.         if (prioritylayer)
  632.         {
  633.             copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_PEN,Machine->pens[0]);
  634.         }
  635.         else
  636.         {
  637.             copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  638.         }
  639.     }
  640. }
  641.  
  642. void ldrun_draw_background(struct osd_bitmap *bitmap, int prioritylayer)
  643. {
  644.     int offs;
  645.  
  646.  
  647.     /* for every character in the Video RAM, check if it has been modified */
  648.     /* since last time and update it accordingly. */
  649.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  650.     {
  651.         if ((dirtybuffer[offs] || dirtybuffer[offs+1]) && !(!prioritylayer && (videoram[offs+1] & 0x04)))
  652.         {
  653.             int sx,sy,flipx;
  654.  
  655.  
  656.             dirtybuffer[offs] = 0;
  657.             dirtybuffer[offs+1] = 0;
  658.  
  659.             sx = (offs/2) % 64;
  660.             sy = (offs/2) / 64;
  661.             flipx = videoram[offs+1] & 0x20;
  662.  
  663.             if (flipscreen)
  664.             {
  665.                 sx = 63 - sx;
  666.                 sy = 31 - sy;
  667.                 flipx = !flipx;
  668.             }
  669.  
  670.             drawgfx(tmpbitmap,Machine->gfx[0],
  671.                     videoram[offs] + ((videoram[offs+1] & 0xc0) << 2),
  672.                     videoram[offs+1] & 0x1f,
  673.                     flipx,flipscreen,
  674.                     8*sx,8*sy,
  675.                     0,TRANSPARENCY_NONE,0);
  676.         }
  677.     }
  678.  
  679.  
  680.     {
  681.         int scrolly;    /* ldrun3 only */
  682.  
  683.         if (flipscreen)
  684.             scrolly = irem_background_vscroll;
  685.         else
  686.             scrolly = -irem_background_vscroll;
  687.  
  688.         if (prioritylayer)
  689.         {
  690.             copyscrollbitmap(bitmap,tmpbitmap,0,0,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_PEN,Machine->pens[0]);
  691.         }
  692.         else
  693.         {
  694.             copyscrollbitmap(bitmap,tmpbitmap,0,0,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  695.         }
  696.     }
  697. }
  698.  
  699. /* almost identical but scrolling background, more characters, */
  700. /* no char x flip, and more sprites */
  701. void ldrun4_draw_background(struct osd_bitmap *bitmap)
  702. {
  703.     int offs;
  704.  
  705.  
  706.     /* for every character in the Video RAM, check if it has been modified */
  707.     /* since last time and update it accordingly. */
  708.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  709.     {
  710.         if (dirtybuffer[offs] || dirtybuffer[offs+1])
  711.         {
  712.             int sx,sy;
  713.  
  714.  
  715.             dirtybuffer[offs] = 0;
  716.             dirtybuffer[offs+1] = 0;
  717.  
  718.             sx = (offs/2) % 64;
  719.             sy = (offs/2) / 64;
  720.  
  721.             if (flipscreen)
  722.             {
  723.                 sx = 63 - sx;
  724.                 sy = 31 - sy;
  725.             }
  726.  
  727.             drawgfx(tmpbitmap,Machine->gfx[0],
  728.                     videoram[offs] + ((videoram[offs+1] & 0xc0) << 2) + ((videoram[offs+1] & 0x20) << 5),
  729.                     videoram[offs+1] & 0x1f,
  730.                     flipscreen,flipscreen,
  731.                     8*sx,8*sy,
  732.                     0,TRANSPARENCY_NONE,0);
  733.         }
  734.     }
  735.  
  736.  
  737.     {
  738.         int scrollx;
  739.  
  740.         if (flipscreen)
  741.             scrollx = irem_background_hscroll + 2;
  742.         else
  743.             scrollx = -irem_background_hscroll + 2;
  744.  
  745.         copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  746.     }
  747. }
  748.  
  749. void lotlot_draw_background(struct osd_bitmap *bitmap)
  750. {
  751.     int offs;
  752.  
  753.  
  754.     /* for every character in the Video RAM, check if it has been modified */
  755.     /* since last time and update it accordingly. */
  756.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  757.     {
  758.         if (dirtybuffer[offs] || dirtybuffer[offs+1])
  759.         {
  760.             int sx,sy,flipx;
  761.  
  762.  
  763.             dirtybuffer[offs] = 0;
  764.             dirtybuffer[offs+1] = 0;
  765.  
  766.             sx = (offs/2) % 32;
  767.             sy = (offs/2) / 32;
  768.             flipx = videoram[offs+1] & 0x20;
  769.  
  770.             if (flipscreen)
  771.             {
  772.                 sx = 31 - sx;
  773.                 sy = 31 - sy;
  774.                 flipx = !flipx;
  775.             }
  776.  
  777.             drawgfx(tmpbitmap,Machine->gfx[0],
  778.                     videoram[offs] + ((videoram[offs+1] & 0xc0) << 2),
  779.                     videoram[offs+1] & 0x1f,
  780.                     flipx,flipscreen,
  781.                     12*sx + 64,10*sy - 32,
  782.                     0,TRANSPARENCY_NONE,0);
  783.         }
  784.     }
  785.  
  786.  
  787.     copybitmap(bitmap,tmpbitmap,0,0,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  788.  
  789.  
  790.     for (offs = irem_textram_size - 2;offs >= 0;offs -= 2)
  791.     {
  792.         int sx,sy;
  793.  
  794.  
  795.         sx = (offs/2) % 32;
  796.         sy = (offs/2) / 32;
  797.  
  798.         if (flipscreen)
  799.         {
  800.             sx = 31 - sx;
  801.             sy = 31 - sy;
  802.         }
  803.  
  804.         drawgfx(bitmap,Machine->gfx[2],
  805.                 irem_textram[offs] + ((irem_textram[offs + 1] & 0xc0) << 2),
  806.                 (irem_textram[offs + 1] & 0x1f),
  807.                 flipscreen,flipscreen,
  808.                 12*sx + 64,10*sy - 32,
  809.                 &Machine->drv->visible_area,TRANSPARENCY_PEN, 0);
  810.     }
  811. }
  812.  
  813. static void kidniki_draw_background(struct osd_bitmap *bitmap)
  814. {
  815.     int offs;
  816.  
  817.  
  818.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  819.     {
  820.         if (dirtybuffer[offs] || dirtybuffer[offs+1])
  821.         {
  822.             int sx,sy;
  823.  
  824.  
  825.             dirtybuffer[offs] = 0;
  826.             dirtybuffer[offs+1] = 0;
  827.  
  828.             sx = (offs/2) % 64;
  829.             sy = (offs/2) / 64;
  830.  
  831.             if (flipscreen)
  832.             {
  833.                 sx = 63 - sx;
  834.                 sy = 31 - sy;
  835.             }
  836.  
  837.             drawgfx(tmpbitmap,Machine->gfx[0],
  838.                     videoram[offs] + ((videoram[offs+1] & 0xe0) << 3) + (kidniki_background_bank << 11),
  839.                     videoram[offs+1] & 0x1f,
  840.                     flipscreen,flipscreen,
  841.                     8*sx,8*sy,
  842.                     0,TRANSPARENCY_NONE,0);
  843.         }
  844.     }
  845.  
  846.  
  847.     {
  848.         int scrollx;
  849.  
  850.         if (flipscreen)
  851.             scrollx = irem_background_hscroll + 2;
  852.         else
  853.             scrollx = -irem_background_hscroll + 2;
  854.  
  855.         copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  856.     }
  857. }
  858.  
  859. static void spelunkr_draw_background(struct osd_bitmap *bitmap)
  860. {
  861.     int offs;
  862.  
  863.  
  864.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  865.     {
  866.         if (dirtybuffer[offs] || dirtybuffer[offs+1])
  867.         {
  868.             int sx,sy;
  869.  
  870.  
  871.             dirtybuffer[offs] = 0;
  872.             dirtybuffer[offs+1] = 0;
  873.  
  874.             sx = (offs/2) % 64;
  875.             sy = (offs/2) / 64;
  876.  
  877.             if (flipscreen)
  878.             {
  879.                 sx = 63 - sx;
  880.                 sy = 63 - sy;
  881.             }
  882.  
  883.             drawgfx(tmpbitmap,Machine->gfx[0],
  884.                     videoram[offs]
  885.                             + ((videoram[offs+1] & 0x10) << 4)
  886.                             + ((videoram[offs+1] & 0x20) << 6)
  887.                             + ((videoram[offs+1] & 0xc0) << 3),
  888.                     (videoram[offs+1] & 0x0f) + (spelunk2_palbank << 4),
  889.                     flipscreen,flipscreen,
  890.                     8*sx,8*sy,
  891.                     0,TRANSPARENCY_NONE,0);
  892.         }
  893.     }
  894.  
  895.  
  896.     {
  897.         int scrollx,scrolly;
  898.  
  899.         if (flipscreen)
  900.         {
  901.             scrollx = irem_background_hscroll;
  902.             scrolly = irem_background_vscroll - 128;
  903.         }
  904.         else
  905.         {
  906.             scrollx = -irem_background_hscroll;
  907.             scrolly = -irem_background_vscroll - 128;
  908.         }
  909.  
  910.         copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  911.     }
  912. }
  913.  
  914. static void spelunk2_draw_background(struct osd_bitmap *bitmap)
  915. {
  916.     int offs;
  917.  
  918.  
  919.     for (offs = videoram_size-2;offs >= 0;offs -= 2)
  920.     {
  921.         if (dirtybuffer[offs] || dirtybuffer[offs+1])
  922.         {
  923.             int sx,sy;
  924.  
  925.  
  926.             dirtybuffer[offs] = 0;
  927.             dirtybuffer[offs+1] = 0;
  928.  
  929.             sx = (offs/2) % 64;
  930.             sy = (offs/2) / 64;
  931.  
  932.             if (flipscreen)
  933.             {
  934.                 sx = 63 - sx;
  935.                 sy = 63 - sy;
  936.             }
  937.  
  938.             drawgfx(tmpbitmap,Machine->gfx[0],
  939.                     videoram[offs] + ((videoram[offs+1] & 0xf0) << 4),
  940.                     (videoram[offs+1] & 0x0f) + (spelunk2_palbank << 4),
  941.                     flipscreen,flipscreen,
  942.                     8*sx,8*sy,
  943.                     0,TRANSPARENCY_NONE,0);
  944.         }
  945.     }
  946.  
  947.  
  948.     {
  949.         int scrollx,scrolly;
  950.  
  951.         if (flipscreen)
  952.         {
  953.             scrollx = irem_background_hscroll;
  954.             scrolly = irem_background_vscroll - 128;
  955.         }
  956.         else
  957.         {
  958.             scrollx = -irem_background_hscroll;
  959.             scrolly = -irem_background_vscroll - 128;
  960.         }
  961.  
  962.         copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  963.     }
  964. }
  965.  
  966.  
  967.  
  968.  
  969. static void battroad_draw_text(struct osd_bitmap *bitmap)
  970. {
  971.     int offs;
  972.  
  973.  
  974.     for (offs = irem_textram_size - 2;offs >= 0;offs -= 2)
  975.     {
  976.         int sx,sy;
  977.  
  978.  
  979.         sx = (offs/2) % 32;
  980.         sy = (offs/2) / 32;
  981.  
  982.         if (flipscreen)
  983.         {
  984.             sx = 31 - sx;
  985.             sy = 31 - sy;
  986.         }
  987.  
  988.         drawgfx(bitmap,Machine->gfx[2],
  989.                 irem_textram[offs] + ((irem_textram[offs + 1] & 0x40) << 3) + ((irem_textram[offs + 1] & 0x10) << 4),
  990.                 (irem_textram[offs + 1] & 0x0f),
  991.                 flipscreen,flipscreen,
  992.                 8*sx+128,8*sy,
  993.                 &Machine->drv->visible_area,TRANSPARENCY_PEN, 0);
  994.     }
  995. }
  996.  
  997. static void kidniki_draw_text(struct osd_bitmap *bitmap)
  998. {
  999.     int offs;
  1000.     int scrolly;
  1001.  
  1002.  
  1003.     if (flipscreen)
  1004.         scrolly = kidniki_text_vscroll-0x180;
  1005.     else
  1006.         scrolly = -kidniki_text_vscroll+0x180;
  1007.  
  1008.  
  1009.     for (offs = irem_textram_size - 2;offs >= 0;offs -= 2)
  1010.     {
  1011.         int sx,sy;
  1012.  
  1013.  
  1014.         sx = (offs/2) % 32;
  1015.         sy = (offs/2) / 32;
  1016.  
  1017.         if (flipscreen)
  1018.         {
  1019.             sx = 31 - sx;
  1020.             sy = 31 - sy;
  1021.         }
  1022.  
  1023.         drawgfx(bitmap,Machine->gfx[2],
  1024.                 irem_textram[offs] + ((irem_textram[offs + 1] & 0xc0) << 2),
  1025.                 (irem_textram[offs + 1] & 0x1f),
  1026.                 flipscreen,flipscreen,
  1027.                 12*sx + 64,8*sy + scrolly,
  1028.                 &Machine->drv->visible_area,TRANSPARENCY_PEN, 0);
  1029.     }
  1030. }
  1031.  
  1032. static void spelunkr_draw_text(struct osd_bitmap *bitmap)
  1033. {
  1034.     int offs;
  1035.  
  1036.  
  1037.     for (offs = irem_textram_size - 2;offs >= 0;offs -= 2)
  1038.     {
  1039.         int sx,sy;
  1040.  
  1041.  
  1042.         sx = (offs/2) % 32;
  1043.         sy = (offs/2) / 32;
  1044.  
  1045.         if (flipscreen)
  1046.         {
  1047.             sx = 31 - sx;
  1048.             sy = 31 - sy;
  1049.         }
  1050.  
  1051.         drawgfx(bitmap,Machine->gfx[2],
  1052.                 irem_textram[offs] + ((irem_textram[offs + 1] & 0x10) << 4),
  1053.                 (irem_textram[offs + 1] & 0x0f) + (spelunk2_palbank << 4),
  1054.                 flipscreen,flipscreen,
  1055.                 12*sx + 64,8*sy,
  1056.                 &Machine->drv->visible_area,TRANSPARENCY_PEN, 0);
  1057.     }
  1058. }
  1059.  
  1060.  
  1061.  
  1062. void kungfum_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  1063. {
  1064.     kungfum_draw_background(bitmap);
  1065.     draw_sprites(bitmap, &kungfum_spritevisiblearea, &kungfum_flipspritevisiblearea);
  1066. }
  1067.  
  1068. void battroad_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  1069. {
  1070.     battroad_draw_background(bitmap, 0);
  1071.     draw_priority_sprites(bitmap, 0);
  1072.     battroad_draw_background(bitmap, 1);
  1073.     draw_priority_sprites(bitmap, 1);
  1074.     battroad_draw_text(bitmap);
  1075. }
  1076.  
  1077. void ldrun_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  1078. {
  1079.     ldrun_draw_background(bitmap, 0);
  1080.     draw_priority_sprites(bitmap, 0);
  1081.     ldrun_draw_background(bitmap, 1);
  1082.     draw_priority_sprites(bitmap, 1);
  1083. }
  1084.  
  1085. void ldrun4_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  1086. {
  1087.     ldrun4_draw_background(bitmap);
  1088.     draw_sprites(bitmap, &Machine->drv->visible_area, &Machine->drv->visible_area);
  1089. }
  1090.  
  1091. void lotlot_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  1092. {
  1093.     lotlot_draw_background(bitmap);
  1094.     draw_sprites(bitmap, &Machine->drv->visible_area, &Machine->drv->visible_area);
  1095. }
  1096.  
  1097. void kidniki_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  1098. {
  1099.     kidniki_draw_background(bitmap);
  1100.     draw_sprites(bitmap, &Machine->drv->visible_area, &Machine->drv->visible_area);
  1101.     kidniki_draw_text(bitmap);
  1102. }
  1103.  
  1104. void spelunkr_vh_screenrefresh( struct osd_bitmap *bitmap, int full_refresh )
  1105. {
  1106.     spelunkr_draw_background(bitmap);
  1107.     draw_sprites(bitmap, &Machine->drv->visible_area, &Machine->drv->visible_area);
  1108.     spelunkr_draw_text(bitmap);
  1109. }
  1110.  
  1111. void spelunk2_vh_screenrefresh( struct osd_bitmap *bitmap, int full_refresh )
  1112. {
  1113.     spelunk2_draw_background(bitmap);
  1114.     draw_sprites(bitmap, &Machine->drv->visible_area, &Machine->drv->visible_area);
  1115.     spelunkr_draw_text(bitmap);
  1116. }
  1117.